home *** CD-ROM | disk | FTP | other *** search
/ AMIGA-CD 2 / Amiga-CD - Volume 2.iso / gepackte_disketten / 1994 / 08_94_5.dms / 08_94_5.adf / term-4.0-Source.lha / termASCIITransfer.c < prev    next >
C/C++ Source or Header  |  1994-07-01  |  24KB  |  1,314 lines
  1. /*
  2. **    termASCIITransfer.c
  3. **
  4. **    ASCII file transfer routines
  5. **
  6. **    Copyright © 1990-1994 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termARexxGlobal.h"
  11.  
  12.     /* Local variables. */
  13.  
  14. STATIC LONG        WaitCount,PromptCount;
  15. STATIC UBYTE __far    ASCIISendPrompt[256];
  16. STATIC LONG        ASCIISendPromptLen;
  17. STATIC BYTE        (* ASCIISendLine)(register STRPTR,register LONG);
  18.  
  19. STATIC LONG __regargs
  20. MangleASCIIBuffer(BYTE TranslateCR,BYTE TranslateLF,STRPTR Source,LONG SourceLen,STRPTR Destination)
  21. {
  22.     WORD    CR_Len,
  23.         LF_Len;
  24.     STRPTR    CR_String,
  25.         LF_String;
  26.     UBYTE    Mask;
  27.     LONG    Len = 0;
  28.  
  29.     switch(TranslateCR)
  30.     {
  31.         case CR_IGNORE:
  32.  
  33.             CR_Len = 0;
  34.             break;
  35.  
  36.         case CR_ASCR:
  37.  
  38.             CR_Len        = 1;
  39.             CR_String    = "\r";
  40.             break;
  41.  
  42.         case CR_ASCRLF:
  43.  
  44.             CR_Len        = 2;
  45.             CR_String    = "\r\n";
  46.             break;
  47.     }
  48.  
  49.     switch(TranslateLF)
  50.     {
  51.         case LF_IGNORE:
  52.  
  53.             LF_Len = 0;
  54.             break;
  55.  
  56.         case LF_ASLF:
  57.  
  58.             LF_Len        = 1;
  59.             LF_String    = "\n";
  60.             break;
  61.  
  62.         case LF_ASLFCR:
  63.  
  64.             LF_Len        = 2;
  65.             LF_String    = "\n\r";
  66.             break;
  67.     }
  68.  
  69.     if(Config -> TransferConfig -> StripBit8)
  70.         Mask = 0x7F;
  71.     else
  72.         Mask = 0xFF;
  73.  
  74.     do
  75.     {
  76.         switch(*Source)
  77.         {
  78.             case '\r':
  79.  
  80.                 if(CR_Len)
  81.                 {
  82.                     CopyMem(CR_String,Destination,CR_Len);
  83.  
  84.                     Destination    += CR_Len;
  85.                     Len        += CR_Len;
  86.                 }
  87.  
  88.                 break;
  89.  
  90.             case '\n':
  91.  
  92.                 if(LF_Len)
  93.                 {
  94.                     CopyMem(LF_String,Destination,LF_Len);
  95.  
  96.                     Destination    += LF_Len;
  97.                     Len        += LF_Len;
  98.                 }
  99.  
  100.                 break;
  101.  
  102.             default:
  103.  
  104.                 *Destination++ = (*Source) & Mask;
  105.  
  106.                 Len++;
  107.  
  108.                 break;
  109.         }
  110.  
  111.         Source++;
  112.     }
  113.     while(--SourceLen);
  114.  
  115.     return(Len);
  116. }
  117.  
  118.     /* MatchPrompt():
  119.      *
  120.      *    Search incoming data stream for a match.
  121.      */
  122.  
  123. STATIC BYTE __regargs
  124. MatchPrompt(register STRPTR Data,register LONG Size,register STRPTR Prompt,register LONG PromptLen)
  125. {
  126.     register UBYTE c,Mask;
  127.  
  128.     if(Config -> SerialConfig -> StripBit8)
  129.         Mask = 0x7F;
  130.     else
  131.         Mask = 0xFF;
  132.  
  133.     do
  134.     {
  135.         if(c = ((*Data++) & Mask))
  136.         {
  137.             register BYTE MatchMade;
  138.  
  139.             do
  140.             {
  141.                 MatchMade = FALSE;
  142.  
  143.                 if(PromptCount == WaitCount)
  144.                 {
  145.                     if(c == Prompt[WaitCount] & Mask)
  146.                     {
  147.                         MatchMade = TRUE;
  148.  
  149.                         if(PromptLen == ++PromptCount)
  150.                             return(TRUE);
  151.                     }
  152.                 }
  153.  
  154.                 if(MatchMade)
  155.                     WaitCount++;
  156.                 else
  157.                 {
  158.                     if(WaitCount)
  159.                     {
  160.                         WaitCount = 0;
  161.  
  162.                         PromptCount = 0;
  163.                     }
  164.                     else
  165.                         break;
  166.                 }
  167.             }
  168.             while(!WaitCount);
  169.         }
  170.     }
  171.     while(--Size);
  172.  
  173.     return(FALSE);
  174. }
  175.  
  176.     /* WaitForPrompt(STRPTR Prompt,LONG PromptLen):
  177.      *
  178.      *    Scan the incoming data flow for a certain string.
  179.      */
  180.  
  181. STATIC BYTE __regargs
  182. WaitForPrompt(STRPTR Prompt,LONG PromptLen)
  183. {
  184.     ULONG Signals;
  185.  
  186.     WaitCount = PromptCount = 0;
  187.  
  188.     if(DataHold)
  189.     {
  190.         DataHold = NULL;
  191.  
  192.         RestartSerial(FALSE);
  193.     }
  194.  
  195.     if(CheckIO(ReadRequest))
  196.         Signals = SIG_SERIAL;
  197.     else
  198.         Signals = NULL;
  199.  
  200.     StartTime(Config -> TransferConfig -> SendTimeout / 100,(Config -> TransferConfig -> SendTimeout % 100) * 10000);
  201.  
  202.     for(;;)
  203.     {
  204.         if(Signals & SIG_SERIAL)
  205.         {
  206.             if(!WaitIO(ReadRequest))
  207.             {
  208.                 LONG Length;
  209.  
  210.                 BytesIn++;
  211.  
  212.                 ConProcess(ReadBuffer,1);
  213.  
  214.                 Status = STATUS_READY;
  215.  
  216.                 if(MatchPrompt(ReadBuffer,1,Prompt,PromptLen))
  217.                 {
  218.                     if(!CheckIO(TimeRequest))
  219.                         AbortIO(TimeRequest);
  220.  
  221.                     WaitIO(TimeRequest);
  222.  
  223.                     RestartSerial(FALSE);
  224.  
  225.                     return(TRUE);
  226.                 }
  227.  
  228.                 do
  229.                 {
  230.                         /* Check how many bytes are still in
  231.                          * the serial buffer.
  232.                          */
  233.  
  234.                     WriteRequest -> IOSer . io_Command = SDCMD_QUERY;
  235.  
  236.                     DoIO(WriteRequest);
  237.  
  238.                     if(Length = WriteRequest -> IOSer . io_Actual)
  239.                     {
  240.                         if(Length > Config -> SerialConfig -> SerialBufferSize)
  241.                             Length = Config -> SerialConfig -> SerialBufferSize;
  242.  
  243.                         ReadRequest -> IOSer . io_Command    = CMD_READ;
  244.                         ReadRequest -> IOSer . io_Data        = ReadBuffer;
  245.                         ReadRequest -> IOSer . io_Length    = Length;
  246.  
  247.                         if(!DoIO(ReadRequest))
  248.                         {
  249.                             BytesIn += Length;
  250.  
  251.                             ConProcess(ReadBuffer,Length);
  252.  
  253.                             Status = STATUS_READY;
  254.  
  255.                             if(MatchPrompt(ReadBuffer,Length,Prompt,PromptLen))
  256.                             {
  257.                                 if(!CheckIO(TimeRequest))
  258.                                     AbortIO(TimeRequest);
  259.  
  260.                                 WaitIO(TimeRequest);
  261.  
  262.                                 RestartSerial(FALSE);
  263.  
  264.                                 return(TRUE);
  265.                             }
  266.                         }
  267.                     }
  268.                 }
  269.                 while(Length);
  270.             }
  271.  
  272.             RestartSerial(FALSE);
  273.         }
  274.  
  275.         if(Signals & SIG_TIMER)
  276.         {
  277.             WaitIO(TimeRequest);
  278.  
  279.             return(FALSE);
  280.         }
  281.  
  282.         Signals = Wait(SIG_SERIAL | SIG_TIMER);
  283.     }
  284. }
  285.  
  286.     /* ASCIISendLinePrompt(STRPTR Line,LONG Len):
  287.      *
  288.      *    Send text line, wait for prompt.
  289.      */
  290.  
  291. STATIC BYTE
  292. ASCIISendLinePrompt(STRPTR Line,LONG Len)
  293. {
  294.     LONG i;
  295.  
  296.     if(Len == -1)
  297.         Len = strlen(Line);
  298.  
  299.     while(Len)
  300.     {
  301.         i = 0;
  302.  
  303.         while(i < Len && Line[i] != '\r')
  304.             i++;
  305.  
  306.  
  307.         if(Line[i] == '\r')
  308.         {
  309.             i++;
  310.  
  311.             SerWrite(Line,i);
  312.  
  313.             if(!WaitForPrompt(ASCIISendPrompt,ASCIISendPromptLen))
  314.                 return(FALSE);
  315.         }
  316.         else
  317.         {
  318.             if(i)
  319.                 SerWrite(Line,i);
  320.         }
  321.  
  322.         Len    -= i;
  323.         Line    += i;
  324.     }
  325.  
  326.     return(TRUE);
  327. }
  328.  
  329.     /* ASCIISendLineSimple(STRPTR Line,LONG Len):
  330.      *
  331.      *    Send a text line, no fancy features.
  332.      */
  333.  
  334. STATIC BYTE
  335. ASCIISendLineSimple(STRPTR Line,LONG Len)
  336. {
  337.     if(Len == -1)
  338.         Len = strlen(Line);
  339.  
  340.     SerWrite(Line,Len);
  341.  
  342.     return(TRUE);
  343. }
  344.  
  345.     /* ASCIISendLineDelay(STRPTR Line,LONG Len):
  346.      *
  347.      *    Send a text line, include a delay where necessary.
  348.      */
  349.  
  350. STATIC BYTE
  351. ASCIISendLineDelay(STRPTR Line,LONG Len)
  352. {
  353.     if(Len == -1)
  354.         Len = strlen(Line);
  355.  
  356.     while(Len--)
  357.     {
  358.         SerWrite(Line,1);
  359.  
  360.         if(*Line == '\r')
  361.         {
  362.             if(Config -> TransferConfig -> LineDelay)
  363.                 WaitTime(Config -> TransferConfig -> LineDelay / 100,(Config -> TransferConfig -> LineDelay % 100) * 10000);
  364.         }
  365.         else
  366.         {
  367.             if(Config -> TransferConfig -> CharDelay)
  368.                 WaitTime(Config -> TransferConfig -> CharDelay / 100,(Config -> TransferConfig -> CharDelay % 100) * 10000);
  369.         }
  370.  
  371.         Line++;
  372.     }
  373.  
  374.     return(TRUE);
  375. }
  376.  
  377.     /* ASCIISendLineEcho(STRPTR Line,LONG Len):
  378.      *
  379.      *    Send a text line, wait for single characters to be echoed.
  380.      */
  381.  
  382. STATIC BYTE
  383. ASCIISendLineEcho(STRPTR Line,LONG Len)
  384. {
  385.     ULONG Signals;
  386.  
  387.     if(DataHold)
  388.     {
  389.         DataHold = NULL;
  390.  
  391.         RestartSerial(FALSE);
  392.     }
  393.  
  394.     if(Len == -1)
  395.         Len = strlen(Line);
  396.  
  397.     while(Len--)
  398.     {
  399.         SerWrite(Line,1);
  400.  
  401.         StartTime(Config -> TransferConfig -> SendTimeout / 100,(Config -> TransferConfig -> SendTimeout % 100) * 10000);
  402.  
  403.         FOREVER
  404.         {
  405.             Signals = Wait(SIG_TIMER | SIG_SERIAL);
  406.  
  407.             if(Signals & SIG_SERIAL)
  408.             {
  409.                 if(!WaitIO(ReadRequest))
  410.                 {
  411.                     if(*(UBYTE *)ReadBuffer == *Line)
  412.                     {
  413.                         if(!CheckIO(TimeRequest))
  414.                             AbortIO(TimeRequest);
  415.  
  416.                         WaitIO(TimeRequest);
  417.  
  418.                         RestartSerial(FALSE);
  419.  
  420.                         break;
  421.                     }
  422.  
  423.                     RestartSerial(FALSE);
  424.                 }
  425.                 else
  426.                 {
  427.                     if(!CheckIO(TimeRequest))
  428.                         AbortIO(TimeRequest);
  429.  
  430.                     WaitIO(TimeRequest);
  431.  
  432.                     RestartSerial(FALSE);
  433.  
  434.                     return(FALSE);
  435.                 }
  436.             }
  437.  
  438.             if(Signals & SIG_TIMER)
  439.             {
  440.                 WaitIO(TimeRequest);
  441.  
  442.                 return(FALSE);
  443.             }
  444.         }
  445.  
  446.         Line++;
  447.     }
  448.  
  449.     return(TRUE);
  450. }
  451.  
  452.     /* ASCIISendLineAnyEcho(STRPTR Line,LONG Len):
  453.      *
  454.      *    Send a text line, wait for characters to be echoed.
  455.      */
  456.  
  457. STATIC BYTE
  458. ASCIISendLineAnyEcho(STRPTR Line,LONG Len)
  459. {
  460.     ULONG Signals;
  461.  
  462.     if(DataHold)
  463.     {
  464.         DataHold = NULL;
  465.  
  466.         RestartSerial(FALSE);
  467.     }
  468.  
  469.     if(Len == -1)
  470.         Len = strlen(Line);
  471.  
  472.     while(Len--)
  473.     {
  474.         SerWrite(Line,1);
  475.  
  476.         StartTime(Config -> TransferConfig -> SendTimeout / 100,(Config -> TransferConfig -> SendTimeout % 100) * 10000);
  477.  
  478.         FOREVER
  479.         {
  480.             Signals = Wait(SIG_TIMER | SIG_SERIAL);
  481.  
  482.             if(Signals & SIG_SERIAL)
  483.             {
  484.                 if(!WaitIO(ReadRequest))
  485.                 {
  486.                     if(!CheckIO(TimeRequest))
  487.                         AbortIO(TimeRequest);
  488.  
  489.                     WaitIO(TimeRequest);
  490.  
  491.                     RestartSerial(FALSE);
  492.  
  493.                     break;
  494.                 }
  495.                 else
  496.                 {
  497.                     if(!CheckIO(TimeRequest))
  498.                         AbortIO(TimeRequest);
  499.  
  500.                     WaitIO(TimeRequest);
  501.  
  502.                     RestartSerial(FALSE);
  503.  
  504.                     return(FALSE);
  505.                 }
  506.             }
  507.  
  508.             if(Signals & SIG_TIMER)
  509.             {
  510.                 WaitIO(TimeRequest);
  511.  
  512.                 return(FALSE);
  513.             }
  514.         }
  515.  
  516.         Line++;
  517.     }
  518.  
  519.     return(TRUE);
  520. }
  521.  
  522.     /* ASCIISendLineKeyDelay(STRPTR Line,LONG Len):
  523.      *
  524.      *    Send a text line, include keyboard delay pauses between characters.
  525.      */
  526.  
  527. STATIC BYTE
  528. ASCIISendLineKeyDelay(STRPTR Line,LONG Len)
  529. {
  530.     struct Preferences Prefs;
  531.  
  532.     if(Len == -1)
  533.         Len = strlen(Line);
  534.  
  535.         /* Get current key repeat delay. */
  536.  
  537.     GetPrefs(&Prefs,offsetof(struct Preferences,KeyRptDelay));
  538.  
  539.         /* Any delay specified at all? */
  540.  
  541.     if(Prefs . KeyRptSpeed . tv_secs || Prefs . KeyRptSpeed . tv_micro)
  542.     {
  543.         while(Len--)
  544.         {
  545.             SerWrite(Line++,1);
  546.  
  547.             if(Len)
  548.             {
  549.                 TimeRequest -> tr_node . io_Command    = TR_ADDREQUEST;
  550.                 TimeRequest -> tr_time            = Prefs . KeyRptSpeed;
  551.  
  552.                 DoIO(TimeRequest);
  553.             }
  554.         }
  555.     }
  556.     else
  557.         SerWrite(Line,Len);
  558.  
  559.     return(TRUE);
  560. }
  561.  
  562.     /* ASCIOSendSetup():
  563.      *
  564.      *    Choose the right routine for the text line output job.
  565.      */
  566.  
  567. VOID
  568. ASCIISendSetup()
  569. {
  570.         /* Pick the line send routine. */
  571.  
  572.     switch(Config -> TransferConfig -> PacingMode)
  573.     {
  574.         case PACE_DIRECT:
  575.  
  576.             ASCIISendLine = ASCIISendLineSimple;
  577.             break;
  578.  
  579.         case PACE_ECHO:
  580.  
  581.             if(Config -> TransferConfig -> SendTimeout)
  582.                 ASCIISendLine = ASCIISendLineEcho;
  583.             else
  584.                 ASCIISendLine = ASCIISendLineSimple;
  585.  
  586.             break;
  587.  
  588.         case PACE_ANYECHO:
  589.  
  590.             if(Config -> TransferConfig -> SendTimeout)
  591.                 ASCIISendLine = ASCIISendLineAnyEcho;
  592.             else
  593.                 ASCIISendLine = ASCIISendLineSimple;
  594.  
  595.             break;
  596.  
  597.         case PACE_PROMPT:
  598.  
  599.             if(Config -> TransferConfig -> SendTimeout)
  600.             {
  601.                     /* Prepare the prompt string. */
  602.  
  603.                 if(Config -> TransferConfig -> LinePrompt[0])
  604.                     ASCIISendPromptLen = TranslateString(Config -> TransferConfig -> LinePrompt,ASCIISendPrompt);
  605.                 else
  606.                 {
  607.                     ASCIISendPrompt[0] = 0;
  608.                     ASCIISendPromptLen = 0;
  609.                 }
  610.  
  611.                 ASCIISendLine = ASCIISendLinePrompt;
  612.             }
  613.             else
  614.                 ASCIISendLine = ASCIISendLineSimple;
  615.  
  616.             break;
  617.  
  618.         case PACE_DELAY:
  619.  
  620.             if(Config -> TransferConfig -> LineDelay || Config -> TransferConfig -> CharDelay)
  621.                 ASCIISendLine = ASCIISendLineDelay;
  622.             else
  623.                 ASCIISendLine = ASCIISendLineSimple;
  624.  
  625.             break;
  626.  
  627.         case PACE_KEYBOARD:
  628.  
  629.             ASCIISendLine = ASCIISendLineKeyDelay;
  630.             break;
  631.     }
  632. }
  633.  
  634. BYTE __regargs
  635. InternalASCIIUpload(STRPTR SingleFile,BYTE WaitForIt)
  636. {
  637.     BYTE    OldStatus = Status,DidSend = FALSE;
  638.     BPTR    NewDir,OldDir;
  639.  
  640.         /* We are uploading data. */
  641.  
  642.     Uploading = TRUE;
  643.  
  644.     if(NewDir = Lock(Config -> PathConfig -> ASCIIUploadPath,ACCESS_READ))
  645.         OldDir = CurrentDir(NewDir);
  646.     else
  647.         OldDir = NULL;
  648.  
  649.     BlockWindows();
  650.  
  651.     if(!FileTransferInfo)
  652.     {
  653.         if(SingleFile)
  654.         {
  655.             ULONG Size;
  656.  
  657.             if(Size = GetFileSize(SingleFile))
  658.             {
  659.                 if(FileTransferInfo = AllocFileTransferInfo())
  660.                 {
  661.                     if(!AddFileTransferNode(FileTransferInfo,SingleFile,Size))
  662.                     {
  663.                         FreeFileTransferInfo(FileTransferInfo);
  664.  
  665.                         FileTransferInfo = NULL;
  666.                     }
  667.                 }
  668.             }
  669.         }
  670.         else
  671.         {
  672.             struct FileRequester    *FileRequest;
  673.             UBYTE             DummyBuffer[MAX_FILENAME_LENGTH];
  674.  
  675.             if(FileRequest = GetFile(Window,LocaleString(MSG_TERMTRANSFER_UPLOAD_FILE_TXT + TRANSFER_ASCII),Config -> PathConfig -> ASCIIUploadPath,"",DummyBuffer,"",FALSE,TRUE,FALSE,LocaleString(MSG_TERMTRANSFER_SEND_TXT),TRUE))
  676.             {
  677.                 strcpy(Config -> PathConfig -> ASCIIUploadPath,FileRequest -> rf_Dir);
  678.  
  679.                 ConfigChanged = TRUE;
  680.  
  681.                 FileTransferInfo = BuildFileTransferInfo(FileRequest);
  682.  
  683.                 FreeAslRequest(FileRequest);
  684.             }
  685.         }
  686.     }
  687.     else
  688.     {
  689.         if(SingleFile)
  690.         {
  691.             ULONG Size;
  692.  
  693.             if(Size = GetFileSize(SingleFile))
  694.             {
  695.                 if(!AddFileTransferNode(FileTransferInfo,SingleFile,Size))
  696.                 {
  697.                     FreeFileTransferInfo(FileTransferInfo);
  698.  
  699.                     FileTransferInfo = NULL;
  700.                 }
  701.             }
  702.         }
  703.     }
  704.  
  705.     TransferAborted = FALSE;
  706.  
  707.     TransferFailed = TRUE;
  708.  
  709.     if(FileTransferInfo)
  710.     {
  711.         struct Window *ThisWindow;
  712.  
  713.         if(ThisWindow = CreateASCIIWindow(TRUE))
  714.         {
  715.             struct Buffer    *File;
  716.             LONG         Chars = 0,Lines = 0,Len,i;
  717.             BYTE         Terminated = FALSE;
  718.  
  719.             FileTransferInfo -> DoneSize    = 0;
  720.             FileTransferInfo -> DoneFiles    = 0;
  721.  
  722.             FileTransferInfo -> CurrentFile    = (struct FileTransferNode *)FileTransferInfo -> FileList . mlh_Head;
  723.             FileTransferInfo -> CurrentSize    = FileTransferInfo -> CurrentFile -> Size;
  724.  
  725.             Status = STATUS_UPLOAD;
  726.  
  727.             ASCIISendSetup();
  728.  
  729.             if(DataHold)
  730.             {
  731.                 if(!Config -> TransferConfig -> QuietTransfer)
  732.                 {
  733.                     ConProcess(DataHold,DataSize);
  734.  
  735.                     Status = STATUS_UPLOAD;
  736.                 }
  737.  
  738.                 DataHold = NULL;
  739.  
  740.                 RestartSerial(FALSE);
  741.             }
  742.  
  743.             while(!Terminated && FileTransferInfo -> CurrentFile -> Node . mln_Succ)
  744.             {
  745.                 if(File = BufferOpen(FileTransferInfo -> CurrentFile -> Name,"r"))
  746.                 {
  747.                     UBYTE    DummyBuffer[512],
  748.                         OtherBuffer[256];
  749.                     ULONG    Signals;
  750.                     BYTE    LastCR = FALSE,Skipped = FALSE;
  751.  
  752.                     AddASCIIMessage(ThisWindow,LocaleString(MSG_ASCIIPANEL_OPENING_FILE_TXT),FileTransferInfo -> CurrentFile -> Name);
  753.  
  754.                     while(!Skipped && !Terminated && (Len = BufferRead(File,OtherBuffer,256)) > 0)
  755.                     {
  756.                         if(Len = MangleASCIIBuffer(Config -> TransferConfig -> SendCR,Config -> TransferConfig -> SendLF,OtherBuffer,Len,DummyBuffer))
  757.                         {
  758.                             for(i = 0 ; i < Len ; i++)
  759.                             {
  760.                                 if(DummyBuffer[i] == '\r')
  761.                                 {
  762.                                     Lines++;
  763.  
  764.                                     LastCR = TRUE;
  765.                                 }
  766.                                 else
  767.                                 {
  768.                                     if(DummyBuffer[i] == '\n' && !LastCR)
  769.                                         Lines++;
  770.  
  771.                                     LastCR = FALSE;
  772.                                 }
  773.                             }
  774.  
  775.                             Chars += Len;
  776.  
  777.                             DidSend = TRUE;
  778.  
  779.                             TransferFailed = FALSE;
  780.  
  781.                             (*ASCIISendLine)(DummyBuffer,Len);
  782.                         }
  783.  
  784.                         Signals = CheckSignal(SIG_BREAK | SIG_SERIAL | PORTMASK(ThisWindow -> UserPort));
  785.  
  786.                         if(Signals & SIG_BREAK)
  787.                             Terminated = TransferAborted = TRUE;
  788.  
  789.                         if(Signals & PORTMASK(ThisWindow -> UserPort))
  790.                         {
  791.                             switch(HandleASCIIWindow(ThisWindow))
  792.                             {
  793.                                 case 1:    Terminated = TransferAborted = TRUE;
  794.                                     break;
  795.  
  796.                                 case 2:    Skipped = TRUE;
  797.                                     break;
  798.                             }
  799.  
  800.                             if(Terminated || Skipped)
  801.                                 break;
  802.                         }
  803.  
  804.                         if(Signals & SIG_SERIAL)
  805.                         {
  806.                             if(!WaitIO(ReadRequest))
  807.                             {
  808.                                 LONG Length;
  809.  
  810.                                 if(!Config -> TransferConfig -> QuietTransfer)
  811.                                 {
  812.                                     BytesIn++;
  813.  
  814.                                     ConProcess(ReadBuffer,1);
  815.  
  816.                                     Status = STATUS_UPLOAD;
  817.                                 }
  818.  
  819.                                     /* Check how many bytes are still in
  820.                                      * the serial buffer.
  821.                                      */
  822.  
  823.                                 WriteRequest -> IOSer . io_Command = SDCMD_QUERY;
  824.  
  825.                                 DoIO(WriteRequest);
  826.  
  827.                                 if(Length = WriteRequest -> IOSer . io_Actual)
  828.                                 {
  829.                                     if(Length > Config -> SerialConfig -> SerialBufferSize)
  830.                                         Length = Config -> SerialConfig -> SerialBufferSize;
  831.  
  832.                                     if(Length > Config -> SerialConfig -> Quantum)
  833.                                         Length = Config -> SerialConfig -> Quantum;
  834.  
  835.                                     ReadRequest -> IOSer . io_Command    = CMD_READ;
  836.                                     ReadRequest -> IOSer . io_Data        = ReadBuffer;
  837.                                     ReadRequest -> IOSer . io_Length    = Length;
  838.  
  839.                                     if(!DoIO(ReadRequest))
  840.                                     {
  841.                                         if(!Config -> TransferConfig -> QuietTransfer)
  842.                                         {
  843.                                             BytesIn += Length;
  844.  
  845.                                                 /* Send the data to the console. */
  846.  
  847.                                             ConProcess(ReadBuffer,Length);
  848.  
  849.                                             Status = STATUS_UPLOAD;
  850.                                         }
  851.                                     }
  852.                                 }
  853.                             }
  854.  
  855.                             RestartSerial(FALSE);
  856.                         }
  857.  
  858.                         UpdateASCIIWindow(ThisWindow,Chars,FileTransferInfo -> CurrentFile -> Size,Lines);
  859.                     }
  860.  
  861.                     if(Len < 0)
  862.                     {
  863.                         AddASCIIMessage(ThisWindow,LocaleString(MSG_ASCIIPANEL_ERROR_READING_FILE_TXT),FileTransferInfo -> CurrentFile -> Name);
  864.  
  865.                         TransferFailed = TRUE;
  866.  
  867.                         break;
  868.                     }
  869.  
  870.                     BufferClose(File);
  871.  
  872.                     RemoveUploadListItem(FileTransferInfo -> CurrentFile -> Name);
  873.                 }
  874.                 else
  875.                 {
  876.                     AddASCIIMessage(ThisWindow,LocaleString(MSG_ASCIIPANEL_ERROR_OPENING_FILE_TXT),FileTransferInfo -> CurrentFile -> Name);
  877.  
  878.                     TransferFailed = TRUE;
  879.  
  880.                     break;
  881.                 }
  882.  
  883.                 FileTransferInfo -> DoneSize    += FileTransferInfo -> CurrentSize;
  884.                 FileTransferInfo -> DoneFiles    += 1;
  885.  
  886.                 FileTransferInfo -> CurrentFile  = (struct FileTransferNode *)FileTransferInfo -> CurrentFile -> Node . mln_Succ;
  887.                 FileTransferInfo -> CurrentSize  = FileTransferInfo -> CurrentFile -> Size;
  888.             }
  889.  
  890.             if(TransferFailed || TransferError)
  891.                 WakeUp(ThisWindow,SOUND_BADTRANSFER);
  892.             else
  893.             {
  894.                 WakeUp(ThisWindow,SOUND_GOODTRANSFER);
  895.  
  896.                 WaitTime(2,0);
  897.             }
  898.  
  899.             DeleteASCIIWindow(ThisWindow,TransferFailed && WaitForIt);
  900.         }
  901.  
  902.         FreeFileTransferInfo(FileTransferInfo);
  903.  
  904.         FileTransferInfo = NULL;
  905.     }
  906.  
  907.     if(TransferFailed || TransferAborted)
  908.         Say(LocaleString(MSG_GLOBAL_TRANSFER_FAILED_OR_ABORTED_TXT));
  909.     else
  910.         Say(LocaleString(MSG_GLOBAL_TRANSFER_COMPLETED_TXT));
  911.  
  912.     if(OldDir)
  913.         CurrentDir(OldDir);
  914.  
  915.     if(NewDir)
  916.         UnLock(NewDir);
  917.  
  918.     SendAbort = FALSE;
  919.  
  920.     Status = OldStatus;
  921.  
  922.     ReleaseWindows();
  923.  
  924.     DidTransfer = FALSE;
  925.  
  926.     if(WaitForIt)
  927.     {
  928.         if(Config -> CommandConfig -> DownloadMacro[0])
  929.             SerialCommand(Config -> CommandConfig -> DownloadMacro);
  930.     }
  931.  
  932.     DidTransfer = FALSE;
  933.  
  934.     return(DidSend);
  935. }
  936.  
  937. BYTE __regargs
  938. InternalASCIIDownload(STRPTR Name,BYTE WaitForIt)
  939. {
  940.     struct FileRequester    *FileRequest;
  941.     UBYTE             DummyBuffer[MAX_FILENAME_LENGTH];
  942.     BYTE             OldStatus = Status,DidSend = FALSE;
  943.     BPTR             NewDir,OldDir;
  944.  
  945.     ClearGenericList(GenericListTable[GLIST_DOWNLOAD]);
  946.  
  947.     DownloadPath = Config -> PathConfig -> ASCIIDownloadPath;
  948.  
  949.     if(DownloadPath[0])
  950.     {
  951.         if(NewDir = Lock(DownloadPath,ACCESS_READ))
  952.             OldDir = CurrentDir(NewDir);
  953.         else
  954.             OldDir = NULL;
  955.     }
  956.     else
  957.         NewDir = OldDir = NULL;
  958.  
  959.     BlockWindows();
  960.  
  961.     if(!Name)
  962.     {
  963.         if(FileRequest = GetFile(Window,LocaleString(MSG_TERMTRANSFER_DOWNLOAD_FILE_TXT + TRANSFER_ASCII),DownloadPath,"",DummyBuffer,NULL,TRUE,FALSE,FALSE,LocaleString(MSG_TERMTRANSFER_RECEIVE_TXT),TRUE))
  964.         {
  965.                 /* Save the download path. */
  966.  
  967.             strcpy(DownloadPath,FileRequest -> rf_Dir);
  968.  
  969.             ConfigChanged = TRUE;
  970.  
  971.             FreeAslRequest(FileRequest);
  972.  
  973.             Name = DummyBuffer;
  974.         }
  975.     }
  976.     else
  977.     {
  978.         STRPTR Index;
  979.  
  980.         strcpy(DownloadPath,Name);
  981.  
  982.         ConfigChanged = TRUE;
  983.  
  984.         Index = PathPart(DownloadPath);
  985.  
  986.         *Index = 0;
  987.     }
  988.  
  989.     TransferAborted = FALSE;
  990.  
  991.     TransferFailed = TRUE;
  992.  
  993.     if(Name)
  994.     {
  995.         struct Window *ThisWindow;
  996.  
  997.         if(ThisWindow = CreateASCIIWindow(FALSE))
  998.         {
  999.             struct Buffer *File;
  1000.  
  1001.             if(File = BufferOpen(Name,"w"))
  1002.             {
  1003.                 UBYTE    OtherBuffer[512];
  1004.                 LONG    Chars = 0,Lines = 0,i;
  1005.                 BYTE    Terminated = FALSE;
  1006.                 ULONG    Signals;
  1007.  
  1008.                 AddASCIIMessage(ThisWindow,LocaleString(MSG_ASCIIPANEL_OPENING_FILE_TXT),Name);
  1009.  
  1010.                 TransferFailed = FALSE;
  1011.  
  1012.                 Status = STATUS_DOWNLOAD;
  1013.  
  1014.                 if(DataHold)
  1015.                 {
  1016.                     LONG Size,Len;
  1017.  
  1018.                     do
  1019.                     {
  1020.                         if(DataSize > 256)
  1021.                             Size = 256;
  1022.                         else
  1023.                             Size = DataSize;
  1024.  
  1025.                         if(Len = MangleASCIIBuffer(Config -> TransferConfig -> ReceiveCR,Config -> TransferConfig -> ReceiveLF,DataHold,Size,OtherBuffer))
  1026.                         {
  1027.                             if(Config -> TransferConfig -> IgnoreDataPastArnold)
  1028.                             {
  1029.                                 for(i = 0 ; i < Len ; i++)
  1030.                                 {
  1031.                                     if(OtherBuffer[i] == '\r')
  1032.                                         Lines++;
  1033.  
  1034.                                     if(OtherBuffer[i] == Config -> TransferConfig -> TerminatorChar)
  1035.                                     {
  1036.                                         Len = i;
  1037.  
  1038.                                         Terminated = TRUE;
  1039.  
  1040.                                         break;
  1041.                                     }
  1042.                                 }
  1043.                             }
  1044.                             else
  1045.                             {
  1046.                                 for(i = 0 ; i < Len ; i++)
  1047.                                 {
  1048.                                     if(OtherBuffer[i] == '\r')
  1049.                                         Lines++;
  1050.                                 }
  1051.                             }
  1052.  
  1053.                             if(Len)
  1054.                             {
  1055.                                 Chars += Len;
  1056.  
  1057.                                 if(BufferWrite(File,OtherBuffer,Len) != Len)
  1058.                                 {
  1059.                                     TransferFailed = Terminated = TRUE;
  1060.  
  1061.                                     AddASCIIMessage(ThisWindow,LocaleString(MSG_ASCIIPANEL_ERROR_WRITING_FILE_TXT),Name);
  1062.                                 }
  1063.                             }
  1064.                         }
  1065.  
  1066.                         if(!Config -> TransferConfig -> QuietTransfer)
  1067.                         {
  1068.                             ConProcess(DataHold,Size);
  1069.  
  1070.                             Status = STATUS_DOWNLOAD;
  1071.                         }
  1072.  
  1073.                         DataSize -= Size;
  1074.  
  1075.                         if(DataSize > 0)
  1076.                             DataHold += Size;
  1077.                         else
  1078.                             DataHold = NULL;
  1079.                     }
  1080.                     while(DataHold && !Terminated);
  1081.  
  1082.                     RestartSerial(FALSE);
  1083.  
  1084.                     UpdateASCIIWindow(ThisWindow,Chars,0,Lines);
  1085.                 }
  1086.  
  1087.                 if(!Terminated)
  1088.                 {
  1089.                     StartTime(5,0);
  1090.  
  1091.                     do
  1092.                     {
  1093.                         Signals = Wait(SIG_BREAK | SIG_SERIAL | SIG_TIMER | PORTMASK(ThisWindow -> UserPort));
  1094.  
  1095.                         if(Signals & PORTMASK(ThisWindow -> UserPort))
  1096.                         {
  1097.                             if(HandleASCIIWindow(ThisWindow))
  1098.                                 break;
  1099.                         }
  1100.  
  1101.                         if(Signals & SIG_SERIAL)
  1102.                         {
  1103.                             StopTime();
  1104.  
  1105.                             if(!WaitIO(ReadRequest))
  1106.                             {
  1107.                                 LONG Length;
  1108.  
  1109.                                 BytesIn++;
  1110.  
  1111.                                 if(!Config -> TransferConfig -> QuietTransfer)
  1112.                                 {
  1113.                                     ConProcess(ReadBuffer,1);
  1114.  
  1115.                                     Status = STATUS_DOWNLOAD;
  1116.                                 }
  1117.  
  1118.                                 if(Length = MangleASCIIBuffer(Config -> TransferConfig -> ReceiveCR,Config -> TransferConfig -> ReceiveLF,ReadBuffer,1,OtherBuffer))
  1119.                                 {
  1120.                                     if(Config -> TransferConfig -> IgnoreDataPastArnold)
  1121.                                     {
  1122.                                         for(i = 0 ; i < Length ; i++)
  1123.                                         {
  1124.                                             if(OtherBuffer[i] == Config -> TransferConfig -> TerminatorChar)
  1125.                                             {
  1126.                                                 Length = i;
  1127.  
  1128.                                                 Terminated = TRUE;
  1129.  
  1130.                                                 break;
  1131.                                             }
  1132.                                         }
  1133.  
  1134.                                         if(Terminated)
  1135.                                         {
  1136.                                             RestartSerial(FALSE);
  1137.  
  1138.                                             break;
  1139.                                         }
  1140.                                     }
  1141.  
  1142.                                     if(Length)
  1143.                                     {
  1144.                                         if(BufferWrite(File,OtherBuffer,Length) != Length)
  1145.                                         {
  1146.                                             TransferFailed = Terminated = TRUE;
  1147.  
  1148.                                             AddASCIIMessage(ThisWindow,LocaleString(MSG_ASCIIPANEL_ERROR_WRITING_FILE_TXT),Name);
  1149.                                         }
  1150.  
  1151.                                         for(i = 0 ; i < Length ; i++)
  1152.                                         {
  1153.                                             if(OtherBuffer[i] == '\r')
  1154.                                                 Lines++;
  1155.                                         }
  1156.  
  1157.                                         Chars += Length;
  1158.                                     }
  1159.                                 }
  1160.  
  1161.                                     /* Check how many bytes are still in
  1162.                                      * the serial buffer.
  1163.                                      */
  1164.  
  1165.                                 WriteRequest -> IOSer . io_Command = SDCMD_QUERY;
  1166.  
  1167.                                 DoIO(WriteRequest);
  1168.  
  1169.                                 if(Length = WriteRequest -> IOSer . io_Actual)
  1170.                                 {
  1171.                                     if(Length > Config -> SerialConfig -> SerialBufferSize)
  1172.                                         Length = Config -> SerialConfig -> SerialBufferSize;
  1173.  
  1174.                                     if(Length > Config -> SerialConfig -> Quantum)
  1175.                                         Length = Config -> SerialConfig -> Quantum;
  1176.  
  1177.                                     if(Length > 256)
  1178.                                         Length = 256;
  1179.  
  1180.                                     ReadRequest -> IOSer . io_Command    = CMD_READ;
  1181.                                     ReadRequest -> IOSer . io_Data        = ReadBuffer;
  1182.                                     ReadRequest -> IOSer . io_Length    = Length;
  1183.  
  1184.                                     if(!DoIO(ReadRequest))
  1185.                                     {
  1186.                                         BytesIn += Length;
  1187.  
  1188.                                             /* Send the data to the console. */
  1189.  
  1190.                                         if(!Config -> TransferConfig -> QuietTransfer)
  1191.                                         {
  1192.                                             ConProcess(ReadBuffer,Length);
  1193.  
  1194.                                             Status = STATUS_DOWNLOAD;
  1195.                                         }
  1196.  
  1197.                                         if(Length = MangleASCIIBuffer(Config -> TransferConfig -> ReceiveCR,Config -> TransferConfig -> ReceiveLF,ReadBuffer,Length,OtherBuffer))
  1198.                                         {
  1199.                                             if(Config -> TransferConfig -> IgnoreDataPastArnold)
  1200.                                             {
  1201.                                                 for(i = 0 ; i < Length ; i++)
  1202.                                                 {
  1203.                                                     if(OtherBuffer[i] == '\r')
  1204.                                                         Lines++;
  1205.  
  1206.                                                     if(OtherBuffer[i] == Config -> TransferConfig -> TerminatorChar)
  1207.                                                     {
  1208.                                                         Length = i;
  1209.  
  1210.                                                         Terminated = TRUE;
  1211.  
  1212.                                                         break;
  1213.                                                     }
  1214.                                                 }
  1215.                                             }
  1216.                                             else
  1217.                                             {
  1218.                                                 for(i = 0 ; i < Length ; i++)
  1219.                                                 {
  1220.                                                     if(OtherBuffer[i] == '\r')
  1221.                                                         Lines++;
  1222.                                                 }
  1223.                                             }
  1224.  
  1225.                                             if(Length)
  1226.                                             {
  1227.                                                 Chars += Length;
  1228.  
  1229.                                                 if(BufferWrite(File,OtherBuffer,Length) != Length)
  1230.                                                 {
  1231.                                                     TransferFailed = Terminated = TRUE;
  1232.  
  1233.                                                     AddASCIIMessage(ThisWindow,LocaleString(MSG_ASCIIPANEL_ERROR_WRITING_FILE_TXT),Name);
  1234.                                                 }
  1235.                                             }
  1236.                                         }
  1237.                                     }
  1238.                                 }
  1239.  
  1240.                                 UpdateASCIIWindow(ThisWindow,Chars,0,Lines);
  1241.                             }
  1242.  
  1243.                             StartTime(5,0);
  1244.  
  1245.                             Signals &= ~SIG_TIMER;
  1246.  
  1247.                             RestartSerial(FALSE);
  1248.                         }
  1249.  
  1250.                         if(Signals & SIG_TIMER)
  1251.                             Terminated = TRUE;
  1252.  
  1253.                         if(Signals & SIG_BREAK)
  1254.                             TransferAborted = Terminated = TRUE;
  1255.                     }
  1256.                     while(!Terminated);
  1257.  
  1258.                     StopTime();
  1259.                 }
  1260.  
  1261.                 BufferClose(File);
  1262.             }
  1263.             else
  1264.             {
  1265.                 AddASCIIMessage(ThisWindow,LocaleString(MSG_ASCIIPANEL_ERROR_OPENING_FILE_TXT),Name);
  1266.  
  1267.                 TransferFailed = TRUE;
  1268.             }
  1269.  
  1270.             if(TransferFailed || TransferError)
  1271.                 WakeUp(ThisWindow,SOUND_BADTRANSFER);
  1272.             else
  1273.             {
  1274.                 WakeUp(ThisWindow,SOUND_GOODTRANSFER);
  1275.  
  1276.                 WaitTime(2,0);
  1277.             }
  1278.  
  1279.             DeleteASCIIWindow(ThisWindow,TransferFailed && WaitForIt);
  1280.         }
  1281.     }
  1282.  
  1283.     if(TransferFailed || TransferAborted)
  1284.         Say(LocaleString(MSG_GLOBAL_TRANSFER_FAILED_OR_ABORTED_TXT));
  1285.     else
  1286.         Say(LocaleString(MSG_GLOBAL_TRANSFER_COMPLETED_TXT));
  1287.  
  1288.     if(OldDir)
  1289.         CurrentDir(OldDir);
  1290.  
  1291.     if(NewDir)
  1292.         UnLock(NewDir);
  1293.  
  1294.     SendAbort = FALSE;
  1295.  
  1296.     Status = OldStatus;
  1297.  
  1298.     ReleaseWindows();
  1299.  
  1300.     DownloadPath = NULL;
  1301.  
  1302.     DidTransfer = FALSE;
  1303.  
  1304.     if(WaitForIt)
  1305.     {
  1306.         if(Config -> CommandConfig -> DownloadMacro[0])
  1307.             SerialCommand(Config -> CommandConfig -> DownloadMacro);
  1308.     }
  1309.  
  1310.     DidTransfer = FALSE;
  1311.  
  1312.     return(DidSend);
  1313. }
  1314.